פיתוח מערכות תוכנה מבוססות Java אוהד ברזילי

Transcription

1

2 מה בתוכנית? נדון בחלופות להשגת persistency בתוכנה: Relational DB and SQL JDBC persistence layer ORM

3 Persistency...ומה קורה אם באמצע התוכנית יש הפסקת חשמל? על רוב התוכניות להיות מסוגלות לשמור מידע בין ריצות Persistent Data Transient Data )מידע מתמשך( )מידע נדיף, ארעי( מה כל כך קשה בלשמור מידע? אנו יכולים לשמור את המידע לקובץ בעצמנו

4 Persistency Challenges System crashes What is the problem? Large data sets (say 50GB) What are the problems? Simultaneous access by many users Need locks: we know them from OS, but now data on disk; and is there any fun to re-implement them? Heterogeneous Clients Local and remote Different OS Different programming languages Complex data and complex operations

5 Transaction (ACID) Atomicity: guarantee that either all of the tasks of a transaction are performed or none of them are (COMMIT or ROLLBACK). Consistency: ensures that the database remains in a consistent state before the start of the transaction and after the transaction is over (whether successful or not). Isolation: no operation outside the transaction can ever see the data in an intermediate state. This enables transactions to operate independently of and transparent to each other. Durability: once the user has been notified of success, the transaction will persist, and not be undone. This means it will survive system failure, and that the database system has checked the integrity constraints and won't need to abort the transaction

6 What Is a Relational Database Management System? Database Management System = DBMS Relational DBMS = RDBMS A collection of files that store the data A big C program written by someone else that accesses and updates those files for you Where are RDBMS used? Backend for traditional database applications: CRM ERP Banking, insurance, Backend for large Websites Backend for Web services

7 Crash course on Relational Databases and SQL )עצם( =< כל דבר זה טבלה שדות של רשומה עמודות בטבלה :)schema( פעולות על מבנה הטבלאות CREATE, ALTER, DROP פעולות על תוכן הטבלאות: INSERT, SELECT, UPDATE, DELETE פעולות על כמה טבלאות: JOIN (INNER, LEFT, RIGHT) KEYS (PRIMARY, FOREIGN)

8 Primary Key of Order Table KEYS בעיה: המידע משוכפל שלא לצורך Primary Key of Customer Table Foreign Key in Order Table

9 How SELECT works People First_Name Last_Name Gender Age Phone John Smith M Sally Jones F John White M Mary Smith F SELECT First_Name, Last_Name FROM People WHERE Age > 30; Result: John White Mary Smith

10 אתגרי ה SQL יעילות שלמות המידע נורמליזציה של טבלאות עקביות, יתירות, נכונות, Behind the scenes the DBMS has: Query optimizer Query engine Storage management Transaction Management (concurrency, recovery) מדריכים מקוונים:

11 When RDBMS met Java

12 בעיה ראשונה SQL ו Java הן שפות שונות - איך מגשרים על הפער?

13 Java Database Connectivity (JDBC) An interface to communicate with a relational database Allows database agnostic Java code Treat database tables/rows/columns as Java objects JDBC driver An implementation of the JDBC interface Communicates with a particular database Java app JDBC calls JDBC JDBC driver driver Database commands Database Database

14 JDBC Driver Types Type 1: JDBC-ODBC Bridge Type 2: Native API / Partially Java Type 3: Pure Java / Net Protocol. Type 4: Pure Java / Native Protocol.

15 Embedding the DB - Java DB Java DB is Sun's supported distribution of the open source Apache Derby Included as part of Java SE v.6 Written in Java Transactional, secure, easy-to-use standards-based SQL, JDBC API, and Java EE Small footprint - only 2MB Community op/javadb/

16 Eclipse JDBC setup Install driver Download MySQL JDBC driver from the Web Unzip mysql-connector-xxx.jar Add mysql-connector-xxx.jar to Eclipse project Project Properties Java Build Path Libraries Add External JARs

17 JDBC steps 1. Connect to database 2. Query database (or insert/update/delete) 3. Process results 4. Close connection to database

18 import java.sql.*; public class Tester { public static void main(string[] args) { try { // Load JDBC driver Class.forName("com.mysql.jdbc.Driver").newInstance(); // Make connection String url = jdbc:mysql:// /grp?user=user&password=pass Connection conn = DriverManager.getConnection(url); // Create statement Statement stmt = conn.createstatement(); // Query database ResultSet rs = stmt.executequery("select * FROM users"); // Process results while (rs.next()) { <next slide...> } // Cleanup better put in finally clause rs.close(); stmt.close(); conn.close(); } } catch (Exception e) { System.out.println("exception " + e); }

19 Process Result ResultSet rs = stmt.executequery("select * FROM users"); while (rs.next()) { String userid = rs.getstring(1); String firstname = rs.getstring( firstname ); String lastname = rs.getstring( lastname ); String password = rs.getstring(4); int type = rs.getint( type ); System.out.println(userid + + firstname + + lastname + + password + + type); } users table userid firstname lastname password type Bob Bob King cat 0 John John Smith pass 1 Initial Cursor position Cursor after first call to rs.next()

20 JDBC 2.1 Updates, Queries, joins Transactions Prepared Statements Meta Data Callable Statements JDBC 3.0 Savepoints Pooling New Data Types RowSets JDBC Features JDBC 4.0 ease-of-use and programmer productivity SQL 2003 XML as a First-Class SQL Data Type

21 בעיה שנייה Paradigm Mismatch Problems caused when objects need to be stored in relational tables. Granularity Subtypes Identity Associations Graph Navigation Cost

22 Problem of Granularity Data types can have various kinds of granularity STREET is a field in CUSTOMER vs. STREET is a field in ADDRESS Performance vs. Modeling Poor support for user defined types (UDT) in SQL. No implementation is portable. Forces developers to use less flexible representations on the object model.

23 Problem of Subtypes Java objects implements inheritance (super & sub classes) Each sub or super class will define different data & completely different functionality. Polymorphism SQL provides no support for inheritance or polymorphism.

24 Problem of Identity Checking if objects are identical Java defines two notations: Object identity [==] Equality of value [.equals()] In SQL it is just checking if the two primary keys are the same Two or more objects can represent the same row of data SQL surrogate keys are not part of the model

25 Problem of Association Associations represent relation between entities Object references represents associations In SQL association is by foreign keys Object references are directional, foreign keys are not It isn t possible to determine multiplicity of a association just by looking at a class SQL multiplicity is always one-to-one or one-tomany, and can be determined by looking at the foreign key

26 Object Graph Navigation Difference in the way objects are accessed in Java and SQL obj.getdetails().getfirstfield() In SQL it would be a set of select statements with joins. n+1 select problem

27 Cost Of The Mismatch Requires significant time & effort Up to 30%* of code is devoted to handle tedious SQL/JDBC Difficulty in modeling the business entities Need to bridge Object/Relational mismatch * Java Persistence with Hibernate, Christian Bauer and Gavin King

28 ארכיטקטורה של המערכת בעיה 3 על פעולות רבות במערכת התוכנה להיות transactional ולכן חלקים רבים בקוד קוראים או כותבים ל Data Store שבירה של מודולריות שבירה של אבסטרקציה

29 Why relational DB survives? Relational technology is a known quantity, and this alone is sufficient reason for many organizations to choose it. (Java Persistence with Hibernate, Christian Bauer and Gavin King) Relational databases are entrenched because: they re an incredibly flexible and robust approach to data management. Due to the complete and consistent theoretical foundation of the relational data model, relational databases can effectively guarantee and protect the integrity of the data, among other desirable characteristics Data independence: data lives longer than any application does.

30 Layered Architecture A layered architecture defines interfaces between various concerns Layers communicate top to bottom A layer is dependent only on the layer directly below it

31 Implementing A Layered Architecture Hand-coding a persistence layer Using serialization Other technologies Object-oriented database systems XML Object/Relational Mapping framework Using EJB entity beans Hibernate

32 Hand-coding a persistence layer Typically using design patterns such as DAO patterns/patterns/dataaccessobject.html Involves manual coding of the persistence layer Hibernate is about 80,000 LOC + 25,000 lines of Unit test code

33 Using Serialization Used by RMI Data can only be accessed as a whole Serial access

34 Other leads Object-oriented database systems An object-oriented database management system (OODBMS) is more like an extension to the application environment than an external data store The Object Data Management Group (ODMG) is no longer active The Java Data Objects (JDO) specification (published in April 2002) XML persistence A variation on the serialization theme object/hierarchical mismatch

35 Object/Relational Mapping (ORM) Object/Relational Mapping is the automated (and transparent) persistence of objects in a Java application to the tables in a relational database, using metadata that describes the mapping between the objects and the database ORM, in essence, works by (reversibly) transforming data from one representation to another JavaObject int id; String name; String getname() int getid() void setname(string) void setid(int) SQL Table id [int] primary key, name [varchar(50)]

36 Using EJB 2.1 as ORM EJB 2.1 specification describes: bean-managed persistence (BMP) container-managed persistence (CMP) Deficiencies: CMP beans are defined in one-to-one correspondence to the tables of the relational model. Thus, they re too coarse grained On the other hand, CMP beans are also too fine grained to realize the stated goal of EJB: the definition of reusable software components. A reusable component should be a very coarse-grained object, with an external interface that is stable in the face of small changes to the database schema. Support only implementation inheritance, but don t support polymorphic associations and queries Entity beans aren t portable in practice. Capabilities of CMP engines vary widely between vendors, and the mapping metadata is highly vendor-specific Entity beans aren t serializable. We must define additional data transfer objects (DTOs, also called value objects) when we need to transport data to a remote client tier EJB is an intrusive model; it mandates an unnatural Java style and makes reuse of code outside a specific container extremely difficult

37 Hibernate Popular Open Source (LGPL) Object/Relational Mapping (ORM) tool Lightweight Non-intrusive Transparent persistence for POJOs (Plain Old Java Objects) Core of JBoss CMP 2.0 impl. Used as an inspiration for EJB 3.0 and JPA

38 A persistent class Event.java is a simple example for a class whose objects can be made persistent It needs An ID field A parameterless constructor...that's all!

39 package events; Event.java (1) import java.util.date; /** * This sample class uses Hibernate to make its state persistent. */ public class Event { // This id is unique system-wide. // Such unique ids are required by Hibernate for all persistent // classes. private Long id; private String title; private Date date; // A constructor without arguments is required by Hibernate // so that it can recreate this class using Reflection. // It should have package visibility "or greater". public Event() {}

40 Event.java (2) public Long getid() { return id; } private void setid(long id) { this.id = id; } public Date getdate() { return date; } public void setdate(date date) { this.date = date; } public String gettitle() { return title; } } public void settitle(string title) { this.title = title; }

41 Storing, Querying, Recalling EventManager.java shows how to do Transactions Queries We'll take a look at two methods, the simple createandstoreevents() and the more complex addpersontoevent()

42 Storing private Long createandstoreevent(string title, Date thedate) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.begintransaction(); Event theevent = new Event(); theevent.settitle(title); theevent.setdate(thedate); } session.save(theevent); session.gettransaction().commit(); return theevent.getid();

43 Querying... private void addpersontoevent(long personid, Long eventid) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.begintransaction(); Person aperson = (Person) session.createquery("select p from Person p left join fetch p.events where p.id = :pid").setparameter("pid", personid).uniqueresult(); Event anevent = (Event) session.load(event.class, eventid); session.gettransaction().commit(); // End of first unit of work

44 ...and Updating aperson.getevents().add(anevent); // aperson is detached // Begin second unit of work Session session2 = HibernateUtil.getSessionFactory().getCurrentSession(); session2.begintransaction(); session2.update(aperson); // Reattachment of aperson session2.gettransaction().commit(); }

45 מקורות JDO in Google App. Engine: JPA in Google App. Engine:

46 Persistency...ומה קורה אם פורצת שריפה?